home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 014 / unbackup.arc / UNBACKUP.C next >
Encoding:
C/C++ Source or Header  |  1986-07-21  |  4.8 KB  |  269 lines
  1. /*************************************************************************
  2. *                                     *
  3. *  UNBACKUP.C -- MSC Code to permit restoration of DOS backup diskettes  *
  4. *         in no particular order                     *
  5. *          -- Author: Mike Mitchell, Los Alamos National Labs,        *
  6. *              Los Alamos, NM 87545 MS D432             *
  7. *          -- Date:     July, 1986                     *
  8. *                                     *
  9. * This code is being placed into the public domain for anyone to use. I  *
  10. * only request that my name appears as author. Modifications are         *
  11. * encouraged, and if really slick, I would like to see them...       *
  12. *                                     *
  13. *************************************************************************/
  14.  
  15. #include <stdio.h>
  16. #include <stdlib.h>
  17. #include <malloc.h>
  18. #include <signal.h>
  19.  
  20. #define BIGBUF 10000
  21.  
  22. int    no_ignore_path = 0;
  23. int    over_write = 0;
  24. int    verbose = 0;
  25. int    broken_file = 0;
  26. char    *inbuf, *outbuf;
  27. char    cur_dir[128];
  28.  
  29. struct back_hdr {
  30.     char back_magic[2];
  31.     char back_null[3];
  32.     char back_name[78];
  33.     char back_what[1];
  34.     char back_remains[43];
  35. };
  36.  
  37. struct    back_hdr hdr;
  38.  
  39. main(argc,argv)
  40. char **argv;
  41. {
  42.     int handler();
  43.  
  44.     if (argc < 2) {
  45.         printf("Usage: unbackup [-sov] d:file.ext\n");
  46.         printf("Example: unbackup -v a:*.exe\n");
  47.         printf("         unbackup -s a:*.*\n");
  48.         exit(1);
  49.     }
  50.  
  51.     getcwd(cur_dir,127);
  52.  
  53.     if (signal(SIGINT, handler) == (int(*)())-1) {
  54.         printf("unbackup: cannot set SIGINT\n");
  55.         abort();
  56.     }
  57.  
  58.     for (argv++, argc--; argc > 0; argv++, argc--)
  59.  
  60.         switch (**argv) {
  61.  
  62.         case '-':
  63.         case '/':
  64.             parse_switch(++*argv);
  65.             break;
  66.  
  67.         default:
  68.             un_backup(*argv);
  69.             break;
  70.         }
  71.     chdir(cur_dir);
  72.     return(broken_file);
  73. }
  74.  
  75. handler()
  76. {
  77.     printf(">>INTERUPT<<\n");
  78.     fcloseall();
  79.     chdir(cur_dir);
  80.     exit(0);
  81. }
  82.  
  83. parse_switch(switch_string)
  84. char *switch_string;
  85. {
  86.     for ( ; *switch_string != '\0' ; switch_string++)
  87.  
  88.         switch (tolower(*switch_string)) {
  89.  
  90.         case '-':
  91.         case '/':
  92.             break;
  93.  
  94.         case 's':
  95.             no_ignore_path++;
  96.             break;
  97.  
  98.         case 'o':
  99.             over_write++;
  100.             break;
  101.             
  102.         case 'v':
  103.             verbose++;
  104.             break;
  105.  
  106.         default:
  107.             printf("unbackup: switch ignored %c\n",
  108.                 *switch_string);
  109.             break;
  110.         }
  111. }
  112.  
  113. un_backup(file_spec)
  114. char *file_spec;
  115. {
  116.     FILE *in, *out;
  117.     char ch;
  118.     char *out_name, *out_path;
  119.     char *base_name(), *path_name();
  120.     
  121.     if ((in = fopen(file_spec, "rb")) == NULL) {
  122.  
  123.         printf("unbackup: cannot open file %s\n",
  124.             file_spec);
  125.         return;
  126.     }
  127.     
  128.     if (check_header_bad(in)) {
  129.  
  130.         printf("unbackup: incorrect header in %s\n",
  131.             file_spec);
  132.         fclose(in);
  133.         return;
  134.     }
  135.  
  136.     out_name = base_name(hdr.back_name);
  137.     out_path = path_name(hdr.back_name);
  138.     
  139.     if (no_ignore_path) {
  140.  
  141.         make_path(out_path);
  142.         chdir(out_path);
  143.     }
  144.  
  145.     if (access(out_name, NULL) == NULL && !over_write) {
  146.         printf("appending to %s\n", out_name);
  147.         out = fopen(out_name, "ab");
  148.     }
  149.     else {
  150.         printf("writing new to %s\n", out_name);
  151.         out = fopen(out_name, "wb");
  152.     }
  153.  
  154.     inbuf = malloc(BIGBUF);
  155.     outbuf = malloc(BIGBUF);
  156.     setbuf(in, inbuf);
  157.     setbuf(out, outbuf);
  158.     
  159.     if (verbose) 
  160.         printf("%s%c%s\n", (no_ignore_path ? out_path : ""),
  161.             (no_ignore_path ? '\\' : '\0'), out_name);
  162.  
  163.     fread(&ch, sizeof(char), 1, in);
  164.  
  165.     while (!feof(in)) {
  166.  
  167.         fwrite(&ch, sizeof(char), 1, out);
  168.         fread(&ch, sizeof(char), 1, in);
  169.     }
  170.  
  171.     free(inbuf);
  172.     free(outbuf);
  173.     free(out_name);
  174.     free(out_path);
  175.     fclose(out);
  176.     fclose(in);
  177. }
  178.  
  179. check_header_bad(fp)
  180. FILE *fp;
  181. {
  182.     if (fread(&hdr, sizeof(struct back_hdr), 1, fp) != 1)
  183.         
  184.         return(~NULL);
  185.  
  186.     if     ((((hdr.back_magic[0] & 0xff) == 0xff) &&
  187.           ((hdr.back_magic[1] & 0xff) >= 0x01)) &&
  188.          (((hdr.back_null[0] & 0xff)  == NULL) &&
  189.           ((hdr.back_null[1] & 0xff)  == NULL) &&
  190.           ((hdr.back_null[2] & 0xff)  == NULL)))
  191.  
  192.             return(NULL);
  193.  
  194.     if     ((((hdr.back_magic[0] & 0xff) == 0x00) &&
  195.           ((hdr.back_magic[1] & 0xff) >= 0x01)) &&
  196.          (((hdr.back_null[0] & 0xff)  == NULL) &&
  197.           ((hdr.back_null[1] & 0xff)  == NULL) &&
  198.           ((hdr.back_null[2] & 0xff)  == NULL))) {
  199.  
  200.             broken_file = 39;
  201.             return(NULL);
  202.         }
  203.  
  204.     return(~NULL);
  205. }
  206.  
  207. make_path(path)
  208. char *path;
  209. {
  210.     char *path_b, *path_p;
  211.     char *base_name(), *path_name();
  212.     
  213.     if (chdir(path) == NULL)
  214.  
  215.         return;
  216.  
  217.     if (*path == '\0') {
  218.  
  219.         chdir("\\");
  220.         return;
  221.     }
  222.     
  223.     path_b = base_name(path);
  224.     path_p = path_name(path);
  225.     
  226.     make_path(path_p);
  227.     chdir(path_p);
  228.     mkdir(path_b);
  229.  
  230.     free(path_p);
  231.     free(path_b);
  232. }
  233.  
  234. char *base_name(file_spec)
  235. char *file_spec;
  236. {
  237.     char *cp;
  238.  
  239.     cp = malloc(strlen(file_spec) + 1);
  240.     strcpy(cp, file_spec);
  241.     
  242.     for ( ; *cp != '\0' ; cp++)
  243.         ;
  244.  
  245.     for ( ; *cp != '\\' && cp >= file_spec; cp--)
  246.         ;
  247.  
  248.     cp++;
  249.     return (cp);
  250. }
  251.  
  252. char *path_name(file_spec)
  253. char *file_spec;
  254. {
  255.     char *cp, *cp2;
  256.     
  257.     cp = malloc(strlen(file_spec) + 1);
  258.     strcpy(cp, file_spec);
  259.  
  260.     for (cp2 = cp ; *cp2 != '\0' ; cp2++)
  261.         ;
  262.  
  263.     for ( ; *cp2 != '\\' && cp2 >= cp ; cp2--)
  264.         ;
  265.  
  266.     *cp2 = '\0';
  267.     return(cp);
  268. }
  269.